/*
 * TabAtributos.cpp
 *
 *  Created on: 02/06/2013
 *      Author: juan
 */

#include "gui/SubWindow/ClassInfoWindow/TabAtributos.h"
#include "gui/SubWindow/ViewModifyClassInfoWin.h"

#include <sstream>


TabAtributos::TabAtributos():
    frameEdicionAtributo("Propiedades atributo"),
    nombreAtributo("Nombre:"),
    tipoAtributo("Tipo:"),
    valorAtributo("Valor:"),
    publico("Publico"),
    privado("Privado"),
    protegido("Protegido"),
    seleccionado_anterior(false),
    numeroAtributo(1){

    this->add(cajaPrincipal);

    cajaPrincipal.pack_start(cajaListaAtributos,Gtk::PACK_EXPAND_WIDGET,5);
    cajaPrincipal.pack_start(frameEdicionAtributo,Gtk::PACK_SHRINK,5);


    cajaListaAtributos.pack_start(ventanaScrolleable,Gtk::PACK_EXPAND_WIDGET);
    cajaListaAtributos.pack_start(cajaBotonesControlLista,Gtk::PACK_SHRINK);

    ventanaScrolleable.add(treeView);
    ventanaScrolleable.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);

    treeModel = Gtk::TreeStore::create(columnas);
    treeView.set_model(treeModel);
    treeView.append_column("Visivilidad", columnas.visivilidad);
    treeView.append_column("Tipo", columnas.tipo);
    treeView.append_column("Nombre", columnas.nombre);
    treeView.append_column("Valor", columnas.valor);


    cajaBotonesControlLista.pack_start(botonNuevo,Gtk::PACK_SHRINK);
    cajaBotonesControlLista.pack_start(botonEliminar,Gtk::PACK_SHRINK);

    botonNuevo.set_label("Nuevo");
    botonNuevo.signal_clicked().connect(sigc::mem_fun(this, &TabAtributos::on_button_Nuevo_clicked));
    botonEliminar.set_label("Eliminar");
    botonEliminar.signal_clicked().connect(sigc::mem_fun(this, &TabAtributos::on_button_Eliminar_clicked));


    frameEdicionAtributo.add(cajaEdicionAtributo);
    cajaEdicionAtributo.pack_start(*(nombreAtributo.getContenedor()),Gtk::PACK_SHRINK, 2);
    cajaEdicionAtributo.pack_start(*(tipoAtributo.getContenedor()),Gtk::PACK_SHRINK, 2);
    cajaEdicionAtributo.pack_start(*(valorAtributo.getContenedor()),Gtk::PACK_SHRINK, 2);


    cajaEdicionAtributo.pack_start(publico, Gtk::PACK_SHRINK, 2);
    cajaEdicionAtributo.pack_start(privado, Gtk::PACK_SHRINK, 2);
    cajaEdicionAtributo.pack_start(protegido, Gtk::PACK_SHRINK, 2);

    publico.set_active();

    publico.set_group(grupo);
    privado.set_group(grupo);
    protegido.set_group(grupo);

    desactivar_entradas();
}

TabAtributos::~TabAtributos() {
}

void TabAtributos::insertarse(Gtk::Notebook& m_Notebook){
    m_Notebook.append_page(*this, "Atributos");
}

void TabAtributos::inicializarAtributos(std::vector<Atributo*> atributos){

    unsigned i;

    for(i = 0; i < atributos.size() ; i++)
    {
        Gtk::TreeModel::Row row = *(treeModel->append());
        row[columnas.nombre] = atributos[i]->getNombre();
        row[columnas.tipo] = atributos[i]->getTipoDato();
        row[columnas.visivilidad] = Utils::visivilidadEnumToString[atributos[i]->getVisibilidad()];
        row[columnas.valor] = atributos[i]->getValor();
    }

    treeView.signal_row_activated().connect(sigc::mem_fun(this, &TabAtributos::on_row_activated));

}

void TabAtributos::on_row_activated(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column){


    if(seleccionado_anterior){
        actualizar_datos();
    }else{
        activar_entradas();
    }

    Gtk::TreeModel::Row row =  *treeModel->get_iter(path);

    nombreAtributo.getEntry()->set_text(row[columnas.nombre]);
    tipoAtributo.getEntry()->set_text(row[columnas.tipo]);
    valorAtributo.getEntry()->set_text(row[columnas.valor]);


    std::stringstream temporal;
    temporal << row[columnas.visivilidad];

    switch(Utils::visivilidadStringToEnum[temporal.str()]){
    case PRIVATE:
        privado.set_active();
        break;
    case PUBLIC:
        publico.set_active();
        break;
    case PROTECTED:
        protegido.set_active();
        break;
    }

    row_anterior = row;
    seleccionado_anterior = true;
}

void TabAtributos::on_button_Nuevo_clicked(){
	Visibilidad visibilidad = PRIVATE;
    std::stringstream nombreNuevo;
    std::string tipoNuevo = "void";
    std::string valorNuevo = "";

    nombreNuevo << "atributo_" << numeroAtributo;
    numeroAtributo++;

	Gtk::TreeModel::Row row = *(treeModel->append());
	row[columnas.nombre] = nombreNuevo.str();
	row[columnas.tipo] = tipoNuevo;
	row[columnas.visivilidad] = Utils::visivilidadEnumToString[visibilidad];
	row[columnas.valor] = valorNuevo;

    if(seleccionado_anterior){
        actualizar_datos();
    }
    seleccionado_anterior = false;
	limpiar_campos();

	desactivar_entradas();

}

void TabAtributos::on_button_Eliminar_clicked(){
    if(seleccionado_anterior){
        desactivar_entradas();
        treeModel->erase(row_anterior);
        seleccionado_anterior = false;
    }
}

void TabAtributos::limpiar_campos(){
	nombreAtributo.getEntry()->set_text("");
	tipoAtributo.getEntry()->set_text("");
	valorAtributo.getEntry()->set_text("");
}

void TabAtributos::actualizar_datos(){
    row_anterior[columnas.nombre] = nombreAtributo.getEntry()->get_text();
    row_anterior[columnas.tipo] = tipoAtributo.getEntry()->get_text();
    row_anterior[columnas.valor] = valorAtributo.getEntry()->get_text();


    if (publico.get_active()){
        row_anterior[columnas.visivilidad] = Utils::representacionPublico;
    }else if (privado.get_active()){
        row_anterior[columnas.visivilidad] = Utils::representacionPrivado;
    }else{
        row_anterior[columnas.visivilidad] = Utils::representacionProtegido;
    }

}

void TabAtributos::desactivar_entradas(){
    nombreAtributo.getEntry()->set_sensitive(false);
    tipoAtributo.getEntry()->set_sensitive(false);
    valorAtributo.getEntry()->set_sensitive(false);
    publico.set_sensitive(false);
    privado.set_sensitive(false);
    protegido.set_sensitive(false);
}
void TabAtributos::activar_entradas(){
    nombreAtributo.getEntry()->set_sensitive(true);
    tipoAtributo.getEntry()->set_sensitive(true);
    valorAtributo.getEntry()->set_sensitive(true);
    publico.set_sensitive(true);
    privado.set_sensitive(true);
    protegido.set_sensitive(true);
}


std::vector<Atributo*> TabAtributos::getAtributos(){
    std::vector<Atributo*> temporal;

    std::stringstream ss;
    Atributo* atributo;

    std::string tipo;
    std::string nombre;
    std::string valor;
    std::string visibilidad_str;
    Visibilidad visibilidad;

    Gtk::TreeModel::Children children = treeModel->children();

    //Para guardar los cambios actuales si se preciona aceptar
    if(seleccionado_anterior){
        actualizar_datos();
    }


    for(Gtk::TreeModel::Children::iterator iter = children.begin();iter != children.end(); ++iter)
    {
        Gtk::TreeModel::Row row = *iter;

        ss.str(std::string());//Borro lo que tenga el string stream
        ss << row[columnas.tipo];
        tipo = ss.str();

        ss.str(std::string());//Borro lo que tenga el string stream
        ss << row[columnas.nombre];
        nombre = ss.str();

        ss.str(std::string());//Borro lo que tenga el string stream
        ss << row[columnas.valor];
        valor = ss.str();

        ss.str(std::string());//Borro lo que tenga el string stream
        ss << row[columnas.visivilidad];
        visibilidad_str = ss.str();

        visibilidad =  Utils::visivilidadStringToEnum[visibilidad_str];

        atributo = new Atributo(tipo,visibilidad,nombre,false,valor);
        temporal.push_back(atributo);
    }


    return temporal;
}
